package org.csu.mybigpro.service;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.csu.mybigpro.DTO.AiAssistantRequestDto;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;

@Service
public class AiAssistantService {

    @Autowired
    private AiService aiService; // 我们复用之前创建的AiService
    // 【关键改动1】注入我们新创建的、基于MyBatis-Plus的IQuestionService
    @Autowired
    private IQuestionService questionService;
    // 实际项目中，这里应该注入真实的 QuestionService, EvaluationService等
    // @Autowired
    // private QuestionService questionService;

    private final ObjectMapper objectMapper = new ObjectMapper();


    public String getAiAssistantReply(List<AiAssistantRequestDto.ChatMessageDto> chatHistory) throws Exception {
        // 1. 将前端的聊天记录转换为Gemini API要求的格式
        List<Map<String, Object>> contents = new ArrayList<>();
        for (AiAssistantRequestDto.ChatMessageDto message : chatHistory) {
            // AI的消息角色是'model'，用户的消息角色是'user'
            String role = "ai".equals(message.getFrom()) ? "model" : "user";
            contents.add(Map.of("role", role, "parts", List.of(Map.of("text", message.getContent()))));
        }

        List<Map<String, Object>> tools = defineAvailableTools();

        // 2. 发送带有完整历史和工具的请求
        String initialResponseJson = aiService.generateContent(contents, tools, null);
        JsonNode responseNode = objectMapper.readTree(initialResponseJson);
        JsonNode firstCandidate = responseNode.path("candidates").path(0);
        JsonNode functionCallNode = firstCandidate.path("content").path("parts").path(0).path("functionCall");

        if (!functionCallNode.isMissingNode()) {
            // 如果AI要求调用工具
            JsonNode modelTurnParts = firstCandidate.path("content").path("parts");
            Map<String, Object> modelTurn = Map.of("role", "model", "parts", objectMapper.convertValue(modelTurnParts, new TypeReference<List<Object>>(){}));
            contents.add(modelTurn); // 将AI的工具调用请求也加入历史

            String functionName = functionCallNode.path("name").asText();
            JsonNode args = functionCallNode.path("args");
            Object toolResult = executeTool(functionName, args);

            // 构造函数执行结果，角色为'function'
            Map<String, Object> functionResponsePart = Map.of("functionResponse", Map.of("name", functionName, "response", Map.of("content", toolResult)));
            Map<String, Object> functionTurn = Map.of("role", "function", "parts", Collections.singletonList(functionResponsePart));
            contents.add(functionTurn); // 将工具执行结果也加入历史

            // 再次调用AI，传入包含所有步骤的完整历史
            String finalResponseJson = aiService.generateContent(contents, tools, "请根据以上信息，用中文详细回答用户最初的问题。");
            JsonNode finalResponseNode = objectMapper.readTree(finalResponseJson);
            return finalResponseNode.path("candidates").path(0).path("content").path("parts").path(0).path("text").asText("处理工具结果时出现问题。");
        } else {
            // 如果AI不调用工具，直接返回文本
            return firstCandidate.path("content").path("parts").path(0).path("text").asText("我暂时无法回答这个问题。");
        }
    }

    private Object executeTool(String functionName, JsonNode args) {
        if ("getStudentQuestionsByCourse".equals(functionName)) {
            String courseName = args.path("courseName").asText("未知课程");

            // 【关键改动2】调用真实的服务来从数据库获取数据
            return questionService.findSummarizedQuestionsByCourse(courseName);
        }
        return Map.of("error", "未找到名为 " + functionName + " 的工具。");
    }
    private List<Map<String, Object>> defineAvailableTools() {
        // 定义 getStudentQuestionsByCourse 这个工具的结构，让AI能理解
        Map<String, Object> functionDecl = new HashMap<>();
        functionDecl.put("name", "getStudentQuestionsByCourse");
        functionDecl.put("description", "根据课程名称，获取该课程下学生们提出的问题摘要，并且你可以基于这些数据，回答用户的其他类型的要求（比如：提出建议和指导进一步教学等）");

        Map<String, Object> params = new HashMap<>();
        params.put("type", "OBJECT");

        Map<String, Object> properties = new HashMap<>();
        properties.put("courseName", Map.of("type", "STRING", "description", "课程的名称"));

        params.put("properties", properties);
        params.put("required", List.of("courseName"));

        functionDecl.put("parameters", params);

        return Collections.singletonList(Map.of("functionDeclarations", Collections.singletonList(functionDecl)));
    }
}